2048 (DFS using a stack)

• Problem definition
• Suggested approach
• Input/output formats
• Requirements
• Datasets

Problem definition

2048 has been a popular game since its debut in March, 2014.

Before you start, you should get familiar with the game. Here is some references:

• Test drive the game: http://2048game.com
• Wiki: English, Chinese

Suggested approach

As instructed in the class, you can use stack-based DFS (depth-first search) to find the action sequence. For details, please refer to the slides and recording of our coverage of the homework.

On the other hand, if you prefer, you can also use recursive backtracking (which uses an implicit stack) to achieve the same goal. (Try google.)

Input/output formats

In an input file, the first line is N, the number of cases of 2048 game for your program to run. And each 4 following lines is an initial map for 2048 game. In other words, there should be 4*N+1 lines in an input file. For example, the following input file has N=10:

For each case, you need to identify the action sequence to generate the final map. If you can find an action sequence to reach the final map (with at least one element of 2048), you should print the action sequence as well as the final map. For instance, a typical output for the first case of the above input file is shown next. (Note that the action and the final map may not be unique.)

Requirements

• Limits:
  • Max time: 1 minute (total time limit for N=10000).
  • Max memory: 256 MB.
  • Max submissions: 20 times each week.
• You can simply use DFS (exhaustive search) to finish this homework. If you are interested in strategies to speed up the search, here are some clues.
• Note that each map of the game has 16 elements of values ranging from $2^1=2$ to $2^{11}=2048$. As a result, we can use a 64-bit unsigned integer (the data type of "unsigned long long") to represent a map, and each element is characterized by a 4-bit unsigned integer (with values ranging from 0 to 15) to represent its exponent.
• How to convert a map to a number in "unsigned long long" (and vice versa): $$ \left[ \begin{matrix} 2 & 256 & 32 & 2\\ 0 & 4 & 64 & 0\\ 0 & 2 & 0 & 2048\\ 8 & 512 & 0 & 0\\ \end{matrix} \right] = \left[ \begin{matrix} 2^1 & 2^8 & 2^5 & 2^1\\ 2^{-\infty} & 2^1 & 2^6 & x\\ 2^{-\infty} & 2^1 & 2^{-\infty} & 2^{11}\\ 2^3 & 2^9 & 2^{-\infty} & 2^{-\infty}\\ \end{matrix} \right] \Longrightarrow \left[ \begin{matrix} 1 & 8 & 5 & 1\\ -\infty & 1 & 6 & -\infty\\ -\infty & 1 & -\infty & 11\\ 3 & 9 & -\infty & -\infty\\ \end{matrix} \right] \Longrightarrow A= \left[ \begin{matrix} 1 & 8 & 5 & 1\\ 0 & 1 & 6 & 0\\ 0 & 1 & 0 & 11\\ 3 & 9 & 0 & 0\\ \end{matrix} \right] $$ $$ = \left[ \begin{matrix} 0001_2 & 1000_2 & 0101_2 & 0001_2\\ 0000_2 & 0001_2 & 0110_2 & 0000_2\\ 0000_2 & 0001_2 & 0000_2 & 1011_2\\ 0011_2 & 1001_2 & 0000_2 & 0000_2\\ \end{matrix} \right] \Longrightarrow \underbrace{0000}_{A[3,3]} \: \underbrace{0000}_{A[3,2]} \: \underbrace{1001}_{A[3,1]} \: \underbrace{0011}_{A[3,0]} \: \underbrace{1011}_{A[2,3]} \: \underbrace{0000}_{A[2,2]} \: \underbrace{0001}_{A[2,1]} \: \underbrace{0000}_{A[2,0]} \: \underbrace{0000}_{A[1,3]} \: \underbrace{0110}_{A[1,2]} \: \underbrace{0001}_{A[1,1]} \: \underbrace{0000}_{A[1,0]} \: \underbrace{0001}_{A[0,3]} \: \underbrace{0101}_{A[0,2]} \: \underbrace{1000}_{A[0,1]} \: \underbrace{0001}_{A[0,0]} $$ So the last number can be represented as an integer in "unsigned long long" format (64 bits). Note that you can shift $A[m,n]$ to the left by $4(4m+n)$ and do a summation to get the integer in "unsigned long long" format.
• TA will provide a function nextMap() to generate the next map based on the current map and the given action. To use the function, please add the following function prototype in your main program: unsigned long long nextMap(unsigned long long map, int action); where map is the current map, and action=0, 1, 2, 3 corresponding to the action of east, south, west, north, respectively. The function is available as a static library lib.a. It is quite easy to use the library by the following command: g++ -std=c++11 -O2 myProgram.cpp lib.a
• Program usage: Your program should take standard input and generate standard output: myProgram < input.txt > output.txt

Datasets

1. Open test sets
   • N=1: input00001.txt, output00001.txt
   • N=10: input00010.txt, output00010.txt
   • N=10000: input10000.txt, output10000.txt